home *** CD-ROM | disk | FTP | other *** search
/ Aminet 2 / Aminet AMIGA CDROM (1994)(Walnut Creek)[Feb 1994][W.O. 44790-1].iso / Aminet / comm / term / term34Source.lha / termScale.c < prev    next >
C/C++ Source or Header  |  1993-07-16  |  9KB  |  458 lines
  1. /*
  2. **    termScale.c
  3. **
  4. **    Single scaled character output routines
  5. **
  6. **    Copyright © 1990-1993 by Olaf `Olsen' Barthel & MXM
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12.     /* Some static data required by the bitmap scaling routine. */
  13.  
  14. STATIC struct RastPort        *ScaleRPort;
  15. STATIC struct BitMap        *ScaleSrcBitMap,
  16.                 *ScaleDstBitMap;
  17. STATIC struct BitScaleArgs    *ScaleArgs;
  18.  
  19. STATIC WORD             ScaleCache    = -1,
  20.                  ScaleType    = 42,
  21.                  ScaleConfig    = 42,
  22.                  PlaneWidth,
  23.                  PlaneHeight;
  24.  
  25.     /* DeleteScale():
  26.      *
  27.      *    Frees all the data associated with font scaling.
  28.      */
  29.  
  30. VOID
  31. DeleteScale()
  32. {
  33.     WORD i;
  34.  
  35.     if(ScaleArgs)
  36.     {
  37.         FreeVec(ScaleArgs);
  38.  
  39.         ScaleArgs = NULL;
  40.     }
  41.  
  42.     if(ScaleDstBitMap)
  43.     {
  44.         for(i = 0 ; i < ScaleDstBitMap -> Depth ; i++)
  45.         {
  46.             if(ScaleDstBitMap -> Planes[i])
  47.                 FreeRaster(ScaleDstBitMap -> Planes[i],PlaneWidth * 2,PlaneHeight * 2);
  48.         }
  49.  
  50.         FreeVec(ScaleDstBitMap);
  51.  
  52.         ScaleDstBitMap = NULL;
  53.     }
  54.  
  55.     if(ScaleSrcBitMap)
  56.     {
  57.         for(i = 0 ; i < ScaleSrcBitMap -> Depth ; i++)
  58.         {
  59.             if(ScaleSrcBitMap -> Planes[i])
  60.                 FreeRaster(ScaleSrcBitMap -> Planes[i],PlaneWidth,PlaneHeight);
  61.         }
  62.  
  63.         FreeVec(ScaleSrcBitMap);
  64.  
  65.         ScaleSrcBitMap = NULL;
  66.     }
  67.  
  68.     if(ScaleRPort)
  69.     {
  70.         FreeVec(ScaleRPort);
  71.  
  72.         ScaleRPort = NULL;
  73.     }
  74. }
  75.  
  76.     /* CreateScale():
  77.      *
  78.      *    Sets up the data required for real-time font scaling
  79.      *    (bitmaps, rastports, etc.).
  80.      */
  81.  
  82. BYTE
  83. CreateScale()
  84. {
  85.         /* Create a RastPort to render into. */
  86.  
  87.     if(ScaleRPort = (struct RastPort *)AllocVec(sizeof(struct RastPort),MEMF_ANY | MEMF_CLEAR))
  88.     {
  89.         WORD MaxWidth,i;
  90.  
  91.             /* Initialize it. */
  92.  
  93.         InitRastPort(ScaleRPort);
  94.  
  95.         if(GFX)
  96.             MaxWidth = GFX -> tf_XSize;
  97.         else
  98.             MaxWidth = 0;
  99.  
  100.         if(TextFontWidth > MaxWidth)
  101.             MaxWidth = TextFontWidth;
  102.  
  103.             /* Remember dimensions. */
  104.  
  105.         PlaneWidth    = MaxWidth;
  106.         PlaneHeight    = TextFontHeight;
  107.  
  108.             /* Create the bitmap to render into. */
  109.  
  110.         if(ScaleSrcBitMap = (struct BitMap *)AllocVec(sizeof(struct BitMap),MEMF_ANY))
  111.         {
  112.                 /* Initialize the bitmap. */
  113.  
  114.             InitBitMap(ScaleSrcBitMap,Window -> WScreen -> RastPort . BitMap -> Depth,PlaneWidth,PlaneHeight);
  115.  
  116.                 /* Create the bitmap to place the scaled font data into. */
  117.  
  118.             if(ScaleDstBitMap = (struct BitMap *)AllocVec(sizeof(struct BitMap),MEMF_ANY))
  119.             {
  120.                 BYTE AllFine = TRUE;
  121.  
  122.                 InitBitMap(ScaleDstBitMap,Window -> WScreen -> RastPort . BitMap -> Depth,PlaneWidth * 2,PlaneHeight * 2);
  123.  
  124.                     /* Allocate the necessary memory space. */
  125.  
  126.                 for(i = 0 ; AllFine && i < ScaleSrcBitMap -> Depth ; i++)
  127.                 {
  128.                     if(!(ScaleSrcBitMap -> Planes[i] = AllocRaster(PlaneWidth,PlaneHeight)))
  129.                         AllFine = FALSE;
  130.                 }
  131.  
  132.                 if(AllFine)
  133.                 {
  134.                         /* Initialize destination bitmap, it must be
  135.                          * large enough to hold four times the size
  136.                          * of the source data.
  137.                          */
  138.  
  139.                         /* Allocate space for the destination area. */
  140.  
  141.                     for(i = 0 ; AllFine && i < ScaleDstBitMap -> Depth ; i++)
  142.                     {
  143.                         if(!(ScaleDstBitMap -> Planes[i] = AllocRaster(PlaneWidth * 2,PlaneHeight * 2)))
  144.                             AllFine = FALSE;
  145.                     }
  146.  
  147.                     if(AllFine)
  148.                     {
  149.                             /* Put the source bitmap into the source RastPort. */
  150.  
  151.                         ScaleRPort -> BitMap = ScaleSrcBitMap;
  152.  
  153.                             /* Install the fonts. */
  154.  
  155.                         SetFont(ScaleRPort,CurrentFont);
  156.  
  157.                             /* Set the default rendering pens. */
  158.  
  159.                         SetAPen(ScaleRPort,1);
  160.                         SetBPen(ScaleRPort,0);
  161.  
  162.                             /* By default, overwrite data. */
  163.  
  164.                         SetDrMd(ScaleRPort,JAM2);
  165.  
  166.                             /* Allocate space for the bitmap scaling arguments. */
  167.  
  168.                         if(ScaleArgs = (struct BitScaleArgs *)AllocVec(sizeof(struct BitScaleArgs),MEMF_ANY | MEMF_CLEAR))
  169.                         {
  170.                                 /* Initialize the structure. */
  171.  
  172.                             ScaleArgs -> bsa_SrcWidth    = TextFontWidth;
  173.                             ScaleArgs -> bsa_SrcHeight    = TextFontHeight;
  174.  
  175.                             ScaleArgs -> bsa_YSrcFactor    = 1;
  176.  
  177.                             ScaleArgs -> bsa_SrcBitMap    = ScaleSrcBitMap;
  178.                             ScaleArgs -> bsa_DestBitMap    = ScaleDstBitMap;
  179.  
  180.                             return(TRUE);
  181.                         }
  182.                     }
  183.                 }
  184.             }
  185.         }
  186.     }
  187.  
  188.     return(FALSE);
  189. }
  190.  
  191.     /* PrintScaled(UBYTE Char,UBYTE Scale):
  192.      *
  193.      *    This is the big one: since VT100 supports a number of
  194.      *    font sizes (double height, double width, 132 columns),
  195.      *    the approriate characters are scaled in real-time before
  196.      *    they are displayed.
  197.      */
  198.  
  199. VOID __regargs
  200. PrintScaled(STRPTR Buffer,LONG Size,UBYTE Scale)
  201. {
  202.     UWORD SrcY,DestX,DestY,SizeX,Baseline;
  203.  
  204.         /* Determine the scale of the destination character. */
  205.  
  206.     if(ScaleType != Scale || ScaleConfig != Config -> EmulationConfig -> FontScale)
  207.     {
  208.         if(Config -> EmulationConfig -> FontScale == SCALE_HALF)
  209.         {
  210.                 /* Determine scale to be used. */
  211.  
  212.             switch(Scale)
  213.             {
  214.                     /* Half width. */
  215.  
  216.                 case SCALE_ATTR_NORMAL:
  217.  
  218.                     ScaleArgs -> bsa_XDestFactor    = 1;
  219.                     ScaleArgs -> bsa_YDestFactor    = 1;
  220.                     ScaleArgs -> bsa_XSrcFactor    = 2;
  221.  
  222.                     SrcY    = 0;
  223.                     DestX    = MUL_X(CursorX) / 2;
  224.                     SizeX    = TextFontWidth / 2;
  225.  
  226.                     ScaleCache = -1;
  227.  
  228.                     break;
  229.  
  230.                     /* Half width, double height (top bits). */
  231.  
  232.                 case SCALE_ATTR_TOP2X:
  233.  
  234.                     ScaleArgs -> bsa_XDestFactor    = 1;
  235.                     ScaleArgs -> bsa_YDestFactor    = 2;
  236.                     ScaleArgs -> bsa_XSrcFactor    = 1;
  237.  
  238.                     SrcY    = 0;
  239.                     DestX    = MUL_X(CursorX);
  240.                     SizeX    = TextFontWidth;
  241.  
  242.                     ScaleCache = -1;
  243.  
  244.                     break;
  245.  
  246.                     /* Half width, double height (bottom bits). */
  247.  
  248.                 case SCALE_ATTR_BOT2X:
  249.  
  250.                     ScaleArgs -> bsa_XDestFactor    = 1;
  251.                     ScaleArgs -> bsa_YDestFactor    = 2;
  252.                     ScaleArgs -> bsa_XSrcFactor    = 1;
  253.  
  254.                     SrcY    = TextFontHeight;
  255.                     DestX    = MUL_X(CursorX);
  256.                     SizeX    = TextFontWidth;
  257.  
  258.                     ScaleCache = -1;
  259.  
  260.                     break;
  261.             }
  262.         }
  263.         else
  264.         {
  265.                 /* Determine scale to be used. */
  266.  
  267.             switch(Scale)
  268.             {
  269.                     /* Double height (top bits). */
  270.  
  271.                 case SCALE_ATTR_TOP2X:
  272.  
  273.                     ScaleArgs -> bsa_XDestFactor    = 2;
  274.                     ScaleArgs -> bsa_YDestFactor    = 2;
  275.                     ScaleArgs -> bsa_XSrcFactor    = 1;
  276.  
  277.                     SrcY    = 0;
  278.                     DestX    = MUL_X(CursorX) * 2;
  279.                     SizeX    = TextFontWidth * 2;
  280.  
  281.                     ScaleCache = -1;
  282.  
  283.                     break;
  284.  
  285.                     /* Double height (bottom bits). */
  286.  
  287.                 case SCALE_ATTR_BOT2X:
  288.  
  289.                     ScaleArgs -> bsa_XDestFactor    = 2;
  290.                     ScaleArgs -> bsa_YDestFactor    = 2;
  291.                     ScaleArgs -> bsa_XSrcFactor    = 1;
  292.  
  293.                     SrcY    = TextFontHeight;
  294.                     DestX    = MUL_X(CursorX) * 2;
  295.                     SizeX    = TextFontWidth * 2;
  296.  
  297.                     ScaleCache = -1;
  298.  
  299.                     break;
  300.  
  301.                     /* Double width. */
  302.  
  303.                 case SCALE_ATTR_2X:
  304.  
  305.                     ScaleArgs -> bsa_XDestFactor    = 2;
  306.                     ScaleArgs -> bsa_YDestFactor    = 1;
  307.                     ScaleArgs -> bsa_XSrcFactor    = 1;
  308.  
  309.                     SrcY    = 0;
  310.                     DestX    = MUL_X(CursorX) * 2;
  311.                     SizeX    = TextFontWidth * 2;
  312.  
  313.                     ScaleCache = -1;
  314.  
  315.                     break;
  316.             }
  317.         }
  318.  
  319.         ScaleType    = Scale;
  320.         ScaleConfig    = Config -> EmulationConfig -> FontScale;
  321.     }
  322.  
  323.         /* Look for the font type to scale. */
  324.  
  325.     if(ScaleRPort -> Font != CurrentFont)
  326.     {
  327.         SetFont(ScaleRPort,CurrentFont);
  328.  
  329.         ScaleArgs -> bsa_SrcWidth = TextFontWidth;
  330.  
  331.         ScaleCache = -1;
  332.     }
  333.  
  334.         /* Set the approriate colours. */
  335.  
  336.     if(ReadAPen(ScaleRPort) != ReadAPen(RPort))
  337.     {
  338.         SetAPen(ScaleRPort,ReadAPen(RPort));
  339.  
  340.         ScaleCache = -1;
  341.     }
  342.  
  343.     if(ReadBPen(ScaleRPort) != ReadBPen(RPort))
  344.     {
  345.         SetBPen(ScaleRPort,ReadBPen(RPort));
  346.  
  347.         ScaleCache = -1;
  348.     }
  349.  
  350.         /* Calculate topmost line to write to. */
  351.  
  352.     DestY = MUL_Y(CursorY);
  353.  
  354.         /* Remember the font baseline. */
  355.  
  356.     Baseline = CurrentFont -> tf_Baseline;
  357.  
  358.     if(CurrentFont == GFX)
  359.     {
  360.         BYTE Mode = 1;
  361.  
  362.             /* Run down the buffer... */
  363.  
  364.         while(Size--)
  365.         {
  366.             if(GfxTable[*Buffer] == Mode)
  367.             {
  368.                 if(*Buffer != ScaleCache)
  369.                 {
  370.                     ScaleCache = *Buffer;
  371.  
  372.                         /* Print the character to be scaled into the
  373.                          * invisible drawing area.
  374.                          */
  375.  
  376.                     Move(ScaleRPort,0,Baseline);
  377.  
  378.                     Text(ScaleRPort,Buffer++,1);
  379.  
  380.                         /* Scale the font. */
  381.  
  382.                     BitMapScale(ScaleArgs);
  383.                 }
  384.                 else
  385.                     Buffer++;
  386.  
  387.                     /* Render the character. */
  388.  
  389.                 BltBitMapRastPort(ScaleDstBitMap,0,SrcY,RPort,WindowLeft + DestX,WindowTop + DestY,SizeX,TextFontHeight,MINTERM_COPY);
  390.             }
  391.             else
  392.             {
  393.                 ScaleCache = *Buffer;
  394.  
  395.                 if(Mode)
  396.                     SetFont(ScaleRPort,TextFont);
  397.                 else
  398.                     SetFont(ScaleRPort,GFX);
  399.  
  400.                 Mode ^= 1;
  401.  
  402.                     /* Print the character to be scaled into the
  403.                      * invisible drawing area.
  404.                      */
  405.  
  406.                 Move(ScaleRPort,0,Baseline);
  407.  
  408.                 Text(ScaleRPort,Buffer++,1);
  409.  
  410.                     /* Scale the font. */
  411.  
  412.                 BitMapScale(ScaleArgs);
  413.  
  414.                     /* Render the character. */
  415.  
  416.                 BltBitMapRastPort(ScaleDstBitMap,0,SrcY,RPort,WindowLeft + DestX,WindowTop + DestY,SizeX,TextFontHeight,MINTERM_COPY);
  417.             }
  418.  
  419.             DestX += SizeX;
  420.         }
  421.  
  422.         if(!Mode)
  423.             SetFont(ScaleRPort,GFX);
  424.     }
  425.     else
  426.     {
  427.             /* Run down the buffer... */
  428.  
  429.         while(Size--)
  430.         {
  431.             if(*Buffer != ScaleCache)
  432.             {
  433.                 ScaleCache = *Buffer;
  434.  
  435.                     /* Print the character to be scaled into the
  436.                      * invisible drawing area.
  437.                      */
  438.  
  439.                 Move(ScaleRPort,0,Baseline);
  440.  
  441.                 Text(ScaleRPort,Buffer++,1);
  442.  
  443.                     /* Scale the font. */
  444.  
  445.                 BitMapScale(ScaleArgs);
  446.             }
  447.             else
  448.                 Buffer++;
  449.  
  450.                 /* Render the character. */
  451.  
  452.             BltBitMapRastPort(ScaleDstBitMap,0,SrcY,RPort,WindowLeft + DestX,WindowTop + DestY,SizeX,TextFontHeight,MINTERM_COPY);
  453.  
  454.             DestX += SizeX;
  455.         }
  456.     }
  457. }
  458.